home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
GameStar 2003 April
/
Gamestar_50_2003-04_cd1.bin
/
Dema
/
echelonww_demo.exe
/
{app}
/
Modules
/
Menu15_TestSuite.py
< prev
next >
Wrap
Text File
|
2003-01-27
|
28KB
|
763 lines
import testutil
import unittest
from utils import *
from utils.mergeTrees import mergeTrees
from AT.makeTable import makeTable
import sys
import os
import shutil
import Menu15_Mock
import Mock
from Menu15 import CreateDB
from Menu15 import UDB
class Menu15_Checker:
def checkEnabled(self, controls, enabled = 1, msg = ''):
if type(controls) is str:
c = controls
asserter = (self.assert_, self.failIf)[not enabled]
asserter(self.ctrls._isEnabled(c), str(c) + ' is %s; '%('disabled', 'enabled')[not enabled] + msg)
return
for c in controls:
self.checkEnabled(c, enabled, msg)
def checkDisabled(self, *controls):
for c in controls:
self.failIf(self.ctrls._isEnabled(c))
def checkSelection(self, control, selection):
self.assert_(self.ctrls._isShown(control))
self.assertEqual(self.getControl(control).getSelection(), selection)
def checkSelectionItem(self, control, item):
self.assert_(self.ctrls._isShown(control))
widget = self.getControl(control)
selection = widget.getSelection()
self.assertEqual(item, widget.Items[selection])
def checkNumItems(self, control, num_items):
items = self.getControl(control).Items
self.assertEqual(num_items, len(items))
def checkItemEnabled(self, control, index, enabled):
self.assertEqual(enabled, self.getControl(control).Enableds[index])
def checkItems(self, control, ref_items):
items = self.getControl(control).Items
self.assertEqual(len(ref_items), len(items))
for ref_item, item in zip(ref_items, items):
if ref_item is not None:
if type(ref_item) is str:
self.assertEqual(ref_item, item)
else:
key, suff, params = ref_item
self._checkLocalized(item, key, suff, params)
def checkItemsSet(self, control, items):
self.assertSetsEqual(self.getControl(control).Items, items)
def checkAlphabet(self, control, alphabet):
self.assertEqual(getattr(self.ctrls.Alphabet, alphabet.capitalize()),
self.getControl(control)._alphabet)
def checkMaxStrLen(self, control, len):
self.assertEqual(len, self.getControl(control)._max_str_len)
def checkText(self, control, text):
def eq(menu, checked_text):
self.assertEqual(text, checked_text)
self.evalText(control, eq)
def evalText(self, control, check):
self.checkShown(control)
check(self, self.getControl(control).Text)
def evalCaption(self, control, check):
self.checkShown(control)
check(self, self.ctrls._getCaption(control))
def evalItem(self, control, index, check):
items = self.getControl(control).Items
check(self, items[index])
def checkListsLinked(self, name0, name1):
def assertLinked(name0, name1):
l0 = self.getControl(name0)
l1 = self.getControl(name1)
self.assert_(l1 in l0.links, 'List '+name0+' not linked '+name1)
assertLinked(name0, name1)
assertLinked(name1, name0)
def _checkLocalized(self, text, control, suff, expected_params):
screen = control.split('.')[0]
self.checkShown(control)
expected_key = control
if suff:
expected_key += '.'+suff
self.assertEqual(screen, text.folder)
self.assertEqual(expected_key, text.key)
self.checkTextParams(expected_params, text.params)
for param in ('PlayerName', 'PlayerCallsign'):
('%('+param+')s')%text.params
def checkLocalizedKey(self, control, expected_key):
text = self.getControl(control).Text
screen = control.split('.')[0]
self.checkShown(control)
self.assertEqual(screen, text.folder)
self.assertEqual(expected_key, text.key)
def checkTextParams(self, expected_params, params):
for param, value in expected_params.items():
self.assertEqual(value, params[param], ''.join(("param:", `param`, ', expected:', `value`, ', found:', `params[param]`)))
def checkLocalizedText(self, control, suff, expected_params):
self._checkLocalized(self.getControl(control).Text, control, suff, expected_params)
def checkLocalizedCaption(self, control, suff, expected_params):
self._checkLocalized(self.ctrls._getCaption(control), control, suff, expected_params)
def checkSliderValue(self, control, value):
self.checkShown(control)
self.assertEqual(self.getControl(control).value, value)
def checkSliderContinuous(self, control):
self.checkShown(control)
self.checkSliderNumSegments(control, 0)
def checkSliderNumSegments(self, control, value):
self.checkShown(control)
if hasattr(self.getControl(control), 'num_segments'):
self.assertEqual(self.getControl(control).num_segments, value)
else:
self.assertEqual(0, value)
def checkChecker(self, control, value):
self.checkShown(control)
self.assertEqual(self.getControl(control).checked, value)
def checkShownOnly(self, controls):
self.assertSetsEqual(self.ctrls._getShown(), controls)
def checkShown(self, *args):
for arg in args:
if type(arg) is str:
self.assert_(self.ctrls._isShown(arg), '"%s" not shown'%(str(arg), ))
else:
self.checkShown(*arg)
def checkNotShown(self, controls):
for control in controls:
self.failIf(self.ctrls._isShown(control), '"%s" in shown'%(str(control), ))
def checkFocus(self, control):
self.assertEqual(control, self.ctrls._focus)
def checkCaption(self, control, caption):
self.assertEqual(self.ctrls._getCaption(control), caption)
def checkGame(self, game, _gameset, mission, host):
gameset = self.fullGamesetPath(_gameset)
self.assertEqual(gameset, game.gameset)
self.assertEqual(mission, game.mission)
self.assertEqual(host, game.host)
def checkOpenedGame(self, _gameset, mission, host):
game = self.Game._opened_game
self.checkGame(game, _gameset, mission, host)
def checkStartedGame(self, *value):
if len(value)==1:
self.assertEqual(value[0], self.Game._started_game)
else:
self.checkGame(self.Game._started_game, value[0], value[1], 0)
def checkResumedGame(self, value):
self.assertEqual(value, self.Game._resumed_game)
def checkNotResumedGame(self):
self.assertRaises(AttributeError, getattr, self.Game, '_resumed_game')
def checkStartedMission(self, event_name):
self.assertEqual(self.Game._started_game.mission, event_name)
def checkStartedProfile(self, value):
self.assertEqual(self.Game._started_game.profile, value)
def checkGlobalTriggers(self, triggers, access_rules = {}):
profile = UDB.open(self.getProfilePath(self.Game._started_game.profile), 1).toPython()
self.assertEqual(dict(profile['CurrentMission']['GlobalTriggers']),
triggers)
self.assertEqual(dict(profile['CurrentMission']['AccessRules']),
access_rules)
self.assertEqual(len(profile['CurrentMission'].keys()), 2)
def checkNoObjectives(self, primary):
profile = UDB.open(self.getProfilePath(self.Game._started_game.profile), 1).toPython()
m = profile['CurrentMission']
try:
m['PrimaryObjectives']
except KeyError:pass
else:
self.fail('must raise KeyError')
def checkProfile(self, pname, value, value_type, folder, opt_class, opt_name):
profile = UDB.open(self.getProfilePath(pname), 1)
d = profile[folder][opt_class][opt_name]
self.assertEqual(d, value)
self.assertEqual(type(d), value_type)
def checkOption(self, pname, value, value_type, opt_class, opt_name):
self.checkProfile(pname, value, value_type, 'Options', opt_class, opt_name)
def checkProfileFolders(self, pname, data, *folders):
profile = UDB.open(self.getProfilePath(pname), 1)
d = profile
for f in folders: d = d[f]
d = d.toPython()
self.assertEqual(d, data)
def checkProfileOptions(self, pname, data, options_class):
self.checkProfileFolders(pname, data, 'Options', options_class)
def checkProfileServer(self, pname, data):
self.checkProfileOptions(pname, data, 'Server')
def checkProfileControls(self, pname, data, *folders):
self.checkProfileFolders(pname, data, 'Controls', *folders)
def checkProfileKeys(self, pname, data):
self.checkProfileControls(pname, data, 'Keys')
def checkProfileKeysActions(self, pname, data):
self.checkProfileControls(pname, data, 'Keys', 'ActionsList')
def checkProfileDevices(self, pname, data):
self.checkProfileControls(pname, data, 'Devices')
def checkAppliedCraft(self, craft_selection):
self.Game.assertCraftSelection(craft_selection)
def checkVideo(self, video_name):
self.assertEqual(self.Game.Video, video_name)
def checkQuited(self):
self.assert_(self.Game.quited)
def checkNotQuited(self):
self.failIf(self.Game.quited)
def checkProfiles(self, *profiles):
name_ext = [os.path.splitext(fname) for fname in os.listdir(self.profiles_folder.path)]
self.assertSetsEqual([name for name, ext in name_ext if '.epp'==ext],
profiles)
def checkModifier(self, name, value):
self.assertEqual(value, getattr(self.Game.modifiers, name))
def checkEndCaptureKeys(self):
self.failIf(self.ctrls.capturing_keys)
def checkServersRefreshingFrom(self, _from):
self.assertEqual(_from, self.Game._refreshing_from)
def checkConnectTo(self, *addr):
self.assertEqual(addr, tuple(self.Game._connectTo))
def checkDisconnected(self, *addr):
self.failIf(not self.Game._disconnected)
def checkNotDisconnected(self):
try:
self.Game._disconnected
except AttributeError:pass
else:
self.failIf(self.Game._disconnected)
def checkViewport(self, name):
self.assertEqual(name, self.ctrls._viewport)
def checkPreview_objects(self, *objects):
self.assertEqual(objects, tuple(self.Preview.objects))
def checkPreview_craft(self, name, weapons):
self.assertEqual(name, self.Preview.craft.name)
self.assertEqual(list(weapons), self.Preview.craft.slots)
def checkGamma(self, value):
self.assertEqual(value, self.Game._gamma)
def checkGeneralVolume(self, value):
self.assertEqual(value, self.Game._GeneralVolume)
def checkMenuEffectsVolume(self, value):
self.assertEqual(value, self.Game._MenuEffectsVolume)
def checkMenuMusicVolume(self, value):
self.assertEqual(value, self.Game._MenuMusicVolume)
class Menu15_Test(unittest.TestCase, testutil.testutil):
UseRealText = 0
def startHook(self, game):
if self.deferred_showEngbay:
self.menu.showEngBay(*self.deferred_showEngbay)
self.deferred_showEngbay = 0
def addServer_hook(self, servers):
map(self.menu.addServer, servers)
def reloadText(self):
import Mock.Text
reload(Mock.Text)
self.text = Mock.Text
self.text.data = {}
def setUp(self):
self.Preview = Menu15_Mock.initPreview()
self.Game = Menu15_Mock.initGame()
self.Game.startHook = self.startHook
self.Game.addServer_hook = self.addServer_hook
if not self.UseRealText:
import Mock.Text
sys.modules['Menu15.Text'] = Mock.Text
import copy
self.modules = copy.copy(sys.modules)
self.data_folder = None
self.profiles_folder = None
self.menu = None
def reset(self):
self.version = 'last'
sys.modules.clear()
sys.modules.update(self.modules)
self.data_folder = testutil.TempFolder()
shutil.copy('TestData\Menu.dat', self.data_folder.path)
self.profiles_folder = testutil.TempFolder()
self.def_keys_controls = {}
self.actions_order = ''
self.actions = {}
self.Preview.reset()
self.Game.reset()
self.Game.Path = self.data_folder.path
self.Game.ProfilesFolderPath = self.profiles_folder.path
self.game_data = {'ActionsList':{}, 'ActionsOrder':'',
'DefaultControls':{'Keys':{},
'Devices':{'Device':2,
'DeviceSensitivity':0,
'DeviceDeadZone':0,
'DeviceInvertY':0,
'DeviceXasYaw':0,
'Rudder':0,
'RudderSensitivity':0,
'RudderDeadZone':0
}
},
'DefaultOptions':{'Server':{'Name':'DeepBlue',
'PublishOnGameSpy':0,
'NumberOfPlayers':13,
'NumberOfBots':5,
'NumberOfConnections':30,
'KillLimit':0,
'TimeLimit':0,
'EnableColorNames':0,
'NeedToConfirmVictories':0,
'CanStealVictories':0},
'Video':{'Shadows':0,
'Effects':0,
'TransparentWater':0,
'Range':1000.0,
'ObjectsDetail':1.0,
'EffectsDetail':1.0,
'DebrisesDetail':1.0,
'Gamma':1.0},
'Game':{
'ShowFriendsName':0, 'ShowFriendsType':0, 'ShowFriendsDist':0,
'ShowEnemiesName':0, 'ShowEnemiesType':0, 'ShowEnemiesDist':0,
'ShowLead':0, 'ShowThreat':0, 'UnlimitedArmor':0,
'UnlimitedAmmo':0, 'NoDamageFromObjects':0,
'NoDamageFromGround':0, 'NoDamageFromFriends':0,
'AllowEnemiesName':0, 'AllowEnemiesType':0,
'AllowEnemiesDist':0, 'Difficulty':0, 'Debug':0},
'Sound':{'GeneralVolume':7,
'MenuMusicVolume':7,
'MenuEffectsVolume':7,
'GameVolume':7,
'GameHudVolume':7,
'GameRadioVolume':7,
'GameCraftEngineVolume':7,
'GameSoundDetail':0}
}
}
import l10n_params
self.setGameData(l10n_params.l10n)
self.extended_devices = []
self.extended_rudders = []
self.setKilled(0)
self.reloadText()
def exit(self):
self.menu.done()
self.menu = None
sys.modules.clear()
sys.modules.update(self.modules)
self.reloadText()
self.Preview.reset()
lastProfile = self.Game.lastProfile
self.Game.reset()
self.Game.lastProfile = lastProfile
self.Game.Path = self.data_folder.path
self.Game.ProfilesFolderPath = self.profiles_folder.path
testutil.collectGarbage()
def init(self):
gd = UDB.UDB()
gd.update(self.game_data)
UDB.save(self.data_folder.createPath('GameData.dat'), gd)
self.ctrls = Mock.Controls()
self.deferred_showEngbay = 0
self.Game.extended_devices = self.extended_devices
self.Game.extended_rudders = self.extended_rudders
import Menu15.Main
self.menu = Menu15.Main
self.menu.setVersion(self.version)
self.menu.init(self.ctrls)
self.update()
def getControl(self, name):
return self.ctrls.get(name)
def exec_Press(self, *controls):
for control in controls:
self.checkEnabled([control], 1)
self.failIf(not self.ctrls._isShown(control), control)
self.ctrls.Pressed = control
c = self.getControl(control)
if c.Type is 'Check':
c.setChecked(not c.isChecked())
self.update()
def exec_Select(self, control, selection):
self.checkEnabled([control], 1)
self.checkItemEnabled(control, selection, 1)
self.getControl(control).setSelection(selection)
self.ctrls.Pressed = control
self.update()
def setValue(self, control, value):
self.getControl(control).setValue(value)
self.ctrls.Pressed = control
self.update()
def setText(self, control, value):
self.getControl(control).Text = value
self.ctrls.Pressed = control
self.update()
def exec_DoubleClick(self, control, selection):
self.exec_Select(control, selection)
self.exec_Select(control, selection)
def update(self):
self.ctrls.updated = 0
self.menu.update()
assert self.ctrls.updated
def fullGamesetPath(self, name):
return os.path.join(self.Game.getPath(), name)
def setKilled(self, killed):
self.killed = killed
def showGameResults(self):
self.saveKilled(self.killed)
self.saveMissionStatus('completed')
self.menu.showGameResults()
def runMain(self, profiles):
self.setProfiles(profiles)
self.init()
def setGameData(self, data):
self.game_data = mergeTrees(data, self.game_data)
def showEngBay(self, crafts, weapons, def_selection):
class Craft:
def __init__(self, c_data):
self.__dict__.update(c_data)
def getName(self):
return self.name
def getAllowedWeapons(self, slot):
return self.slots[slot]
class Weapon:
def __init__(self, name):
self.name = name
def getName(self):
return self.name
class Selection:
def __init__(self, craft, slots):
self.Craft = craft
self.Slots = list(slots)
self.menu.showEngBay(
dict([(c_idx, Craft(c_data)) for c_idx, c_data in crafts.items()]),
dict([(w_index, Weapon(w_data)) for w_index, w_data in weapons.items()]),
Selection(def_selection[0], def_selection[1]))
self.update()
def defer_showEngBay(self, crafts, weapons, def_selection):
class Craft:
def __init__(self, c_data):
self.__dict__.update(c_data)
def getName(self):
return self.name
def getAllowedWeapons(self, slot):
return self.slots[slot]
class Weapon:
def __init__(self, name):
self.name = name
def getName(self):
return self.name
class Selection:
def __init__(self, craft, slots):
self.Craft = craft
self.Slots = list(slots)
self.deferred_showEngbay = (
dict([(c_idx, Craft(c_data)) for c_idx, c_data in crafts.items()]),
dict([(w_index, Weapon(w_data)) for w_index, w_data in weapons.items()]),
Selection(def_selection[0], def_selection[1]))
def setProfiles(self, profiles, last_profile_name = None):
if last_profile_name is not None:
self.Game.setLastProfile(last_profile_name)
profiles_folder = self.profiles_folder.path
if os.path.isdir(profiles_folder):
shutil.rmtree(profiles_folder)
os.mkdir(profiles_folder)
from Menu15 import ProfileData
for name, data in profiles:
CreateDB.createDbEx(self.getProfilePath(name),
ProfileData.createProfileData(data))
def clearLastProfile(self):
self.Game.setLastProfile('')
def setGamesets(self, gamesets):
self.setGamesetsEx([(name, Menu15_Mock.Campaigns[name]) for name in gamesets])
def setGamesetsEx(self, gamesets):
import glob
for path in glob.glob(os.path.join(self.Game.getPath(), '*.gsl')):
os.remove(path)
for name, data in gamesets:
CreateDB.createGameset(self.fullGamesetPath(name), data)
def setExtendedDevices(self, devices):
self.extended_devices = tuple(devices)
def setExtendedRudders(self, rudders):
self.extended_rudders = tuple(rudders)
def setVersion(self, version):
self.version = version
def setOpenedGame(self, game):
self.Game._opened_game = game
def setStartedGame(self, game):
self.Game._started_game = game
def updateCurrentMission(self, data):
profile_path = self.getProfilePath(self.Game._started_game.profile)
profile = UDB.open(profile_path, 0)
profile['CurrentMission'].update(data)
UDB.save(profile_path, profile)
def updateCurrentMissionLocal(self, data):
profile_path = self.getProfilePath(self.Game._started_game.profile)
profile = UDB.open(profile_path, 0)
if not profile['CurrentMission'].has_key('Local'):
profile['CurrentMission']['Local'] = {}
profile['CurrentMission']['Local'].update(data)
UDB.save(profile_path, profile)
def setObjectives(self, primary={}, secondary={}, other={}):
self.updateCurrentMission({'PrimaryObjectives':primary,
'SecondaryObjectives':secondary,
'OtherObjectives':other})
def setAccessRulez(self, data):
self.updateCurrentMission({'AccessRules':data})
def setGlobalTriggers(self, triggers):
self.updateCurrentMission({'GlobalTriggers':triggers})
def setAwards(self, *awards):
rows = []
table = []
for i, award in enumerate(awards):
name, count = award
rows.append(name)
table.append([count])
awards_table = makeTable(row_names = rows, col_names = ['col_Count'],
table = table)
self.updateCurrentMissionLocal({'AwardsList':awards_table})
def saveKilled(self, killed):
self.updateCurrentMissionLocal({'ClientStatus':['killed', 'landed'][not killed]})
def saveMissionStatus(self, value):
self.updateCurrentMissionLocal({'MissionStatus':value})
def setKillboard(self, rows = [], cols = [], table = []):
table = makeTable(row_names = rows, col_names = cols, table = table)
self.updateCurrentMission({'KillBoard':table})
def getProfilePath(self, name):
return self.profiles_folder.createPath(name+'.epp')
def setProfileAccessDenied(self, profile_name):
profile_path = self.getProfilePath(profile_name)
os.chmod(profile_path, os.R_OK)
def setProfileAccessGranted(self, profile_name):
profile_path = self.getProfilePath(profile_name)
os.chmod(profile_path, 0666)
def openProfile(self, name):
p = UDB.open(self.getProfilePath(name), 0)
return p
def saveProfile(self, name, db):
UDB.save(self.getProfilePath(name), db)
def copyProfile(self, src, dst):
self.saveProfile(dst, self.openProfile(src))
def unlinkProfile(self, name):
os.remove(self.getProfilePath(name))
def sleep(self, sec):
import time
time.sleep(sec)
def openGameset(self, name):
return UDB.open(self.fullGamesetPath(name), 1)
def sendKeys(self, *keys):
self.ctrls.captured_keys = keys
self.ctrls.pressed_keys = keys
self.update()
def sendPressedKeys(self, *keys):
self.ctrls.pressed_keys = keys
self.update()
self.ctrls.pressed_keys = []
def setNetworkSupported(self, is_supported):
self.Game._is_network_supported = is_supported
def ServerInfo(self, s):
class ServerInfo:
name = s['ServerName']
type = s['ServerType']
ping = s['ServerPing']
num_players = s['ServerPlayers']
num_players_max = s['ServerPlayersMax']
campaign = s['CampaignTitle']
mission = s['MissionTitle']
mission_type = s['MissionType']
addr = s['addr']
return ServerInfo
def ServerInfos(self, server_infos):
return map(self.ServerInfo, server_infos)
def setServersList(self, *server_infos):
self.Game.servers = self.ServerInfos(server_infos)
def addServers(self, *server_infos):
map(self.menu.addServer, self.ServerInfos(server_infos))
self.update()
def onConnect(self, gmst, msn):
self.menu.onConnect(gmst, msn)
self.update()
def onError(self, error):
self.menu.onError(error)
self.update()
def showExitScreen(self, restart_enabled):
self.menu.showExitScreen(restart_enabled)
self.update()
def onServerReady(self):
self.menu.onServerReady()
self.update()
def setL10nData(self, folder, key, format):
self.text.data = mergeTrees({folder:{key:format}}, self.text.data)
def setVideo(self, video_name):
self.Game.Video = video_name